Quelle est la différence entre 'git pull' et 'git fetch'?

1
2
Prochain
Dans les termes les plus simples, git pull effectue une extraction git suivie d'une fusion git.
Vous pouvez faire une extraction git à tout moment pour mettre à jour vos branches de suivi à distance sous refs / remotes /  /.
Cette opération ne modifie jamais aucune de vos propres succursales locales sous refs / heads, et peut être effectuée en toute sécurité sans changer votre copie de travail. J'ai même entendu parler de personnes exécutant git fetch périodiquement dans un travail cron en arrière-plan (bien que je ne recommande pas de le faire).
Un git pull est ce que vous feriez pour mettre à jour une branche locale avec sa version distante, tout en mettant à jour vos autres branches de suivi à distance.
Depuis la documentation Git pour git pull:
Dans son mode par défaut, git pull est un raccourci pour git fetch suivi de git merge FETCH_HEAD.
|
Lorsque vous utilisez pull, Git essaie de faire automatiquement votre travail pour vous. Il est sensible au contexte, donc Git fusionnera tous les commits extraits dans la branche dans laquelle vous travaillez actuellement. Pull fusionne automatiquement les commits sans vous permettre de les examiner au préalable. Si vous ne gérez pas étroitement vos succursales, vous pouvez être confronté à de fréquents conflits.
Lorsque vous récupérez, Git rassemble tous les commits de la branche cible qui n'existent pas dans votre branche actuelle et les stocke dans votre référentiel local. Cependant, il ne les fusionne pas avec votre branche actuelle. Ceci est particulièrement utile si vous avez besoin de maintenir votre référentiel à jour, mais que vous travaillez sur quelque chose qui pourrait se casser si vous mettez à jour vos fichiers.
Pour intégrer les commits dans votre branche principale, vous utilisez merge.
|
Il est important de contraster la philosophie de conception de git avec la philosophie d'un outil de contrôle de source plus traditionnel comme SVN.
Subversion a été conçu et construit avec un modèle client / serveur. Il existe un référentiel unique qui est le serveur, et plusieurs clients peuvent récupérer le code du serveur, travailler dessus, puis le remettre sur le serveur. L'hypothèse est que le client peut toujours contacter le serveur lorsqu'il a besoin d'effectuer une opération.
Git a été conçu pour prendre en charge un modèle plus distribué sans avoir besoin d'un référentiel central (bien que vous puissiez certainement en utiliser un si vous le souhaitez). De plus, git a été conçu pour que le client et le "serveur" n'aient pas besoin d'être en ligne en même temps. Git a été conçu pour que les personnes sur un lien non fiable puissent échanger du code par e-mail, même. Il est possible de travailler complètement déconnecté et de graver un CD pour échanger du code via git.
Afin de prendre en charge ce modèle, git gère un référentiel local avec votre code et également un référentiel local supplémentaire qui reflète l'état du référentiel distant. En conservant une copie du référentiel distant localement, git peut déterminer les modifications nécessaires même lorsque le référentiel distant n'est pas accessible. Plus tard, lorsque vous devez envoyer les modifications à quelqu'un d'autre, git peut les transférer sous la forme d'un ensemble de modifications à partir d'un point dans le temps connu du référentiel distant.
git fetch est la commande qui dit "mettre à jour ma copie locale du référentiel distant".
git pull dit "amener les changements dans le référentiel distant là où je garde mon propre code."
Normalement, git pull fait cela en effectuant une extraction git pour mettre à jour la copie locale du référentiel distant, puis en fusionnant les modifications dans votre propre référentiel de code et éventuellement votre copie de travail.
Le point à retenir est de garder à l'esprit qu'il y a souvent au moins trois copies d'un projet sur votre poste de travail. Une copie est votre propre référentiel avec votre propre historique de commit. La deuxième copie est votre copie de travail où vous éditez et construisez. La troisième copie est votre copie locale "mise en cache" d'un référentiel distant.
|
Voici l'image d'Oliver Steele de la façon dont tout cela s'accorde:
S'il y a suffisamment d'intérêt, je suppose que je pourrais mettre à jour l'image pour ajouter git clone et git merge ...
|
Un cas d'utilisation de git fetch est que ce qui suit vous indiquera tout changement dans la branche distante depuis votre dernier pull ... afin que vous puissiez vérifier avant de faire un pull réel, ce qui pourrait changer les fichiers dans votre branche actuelle et votre copie de travail.
git chercher
git diff ... origine
Voir: https://git-scm.com/docs/git-diff concernant la syntaxe double et triple point dans la commande diff
|
Cela m'a coûté un peu de comprendre quelle était la différence, mais c'est une explication simple. master dans votre localhost est une branche.
Lorsque vous clonez un référentiel, vous récupérez l'intégralité du référentiel sur votre hôte local. Cela signifie qu'à ce moment-là vous avez un pointeur origine / maître vers HEAD et un maître pointant vers le même HEAD.
lorsque vous commencez à travailler et que vous effectuez des validations, vous avancez le pointeur principal vers HEAD + vos validations. Mais le pointeur origine / maître pointe toujours vers ce qu'il était lorsque vous avez cloné.
La différence sera donc:
Si vous faites un git fetch, il récupérera simplement toutes les modifications dans le référentiel distant (GitHub) et déplacera le pointeur d'origine / maître vers HEAD. Pendant ce temps, votre directeur de succursale locale continuera à indiquer où il se trouve.
Si vous faites un git pull, il effectuera essentiellement une extraction (comme expliqué précédemment) et fusionnera toutes les nouvelles modifications apportées à votremaster branche et déplacez le pointeur sur HEAD.
|
Parfois, une représentation visuelle aide.
|
Brièvement
git fetch est similaire à pull mais ne fusionne pas. c'est-à-dire qu'il récupère les mises à jour à distance (références et objets) mais votre local reste le même (c'est-à-dire que l'origine / le maître est mis à jour mais le maître reste le même).
git pull sort d'une télécommande et fusionne instantanément.
Plus
git clone clone un dépôt.
git rebase enregistre les éléments de votre branche actuelle qui ne se trouvent pas dans la branche amont dans une zone temporaire. Votre succursale est maintenant la même qu'avant le début de vos modifications. Donc, git pull -rebase abaissera les modifications à distance, rembobinera votre branche locale, rejouera vos modifications par-dessus votre branche actuelle une par une jusqu'à ce que vous soyez à jour.
De plus, git branch -a vous montrera exactement ce qui se passe avec toutes vos branches - locales et distantes.
Ce billet de blog a été utile:
La différence entre git pull, git fetch et git clone (et git rebase) - Mike Pearce
et couvre git pull, git fetch, git clone et git rebase.
====
MISE À JOUR
J'ai pensé mettre à jour ceci pour montrer comment vous l'utiliseriez réellement dans la pratique.
Mettez à jour votre dépôt local à partir de la télécommande (mais ne fusionnez pas):
git chercher
Après avoir téléchargé les mises à jour, voyons les différences:
git diff master origin / master
Si vous êtes satisfait de ces mises à jour, fusionnez:
git pull
Remarques:
À l'étape 2: Pour en savoir plus sur les différences entre local et distant, voir: Comment comparer une branche git locale avec sa branche distante?
À l'étape 3: il est probablement plus précis (par exemple sur un dépôt à évolution rapide) de faire une origine git rebase ici. Voir le commentaire de @Justin Ohms dans une autre réponse.
Voir aussi: http://longair.net/blog/2009/04/16/git-fetch-and-merge/
|
git-pull - Récupère et fusionne avec un autre référentiel ou une branche locale
SYNOPSIS
git pull…
LA DESCRIPTION
Exécute git-fetch avec les paramètres donnés, et appelle git-merge pour fusionner le
tête (s) récupérée dans la branche actuelle. Avec --rebase, appelle git-rebase
au lieu de git-merge.
Notez que vous pouvez utiliser. (répertoire courant) comme  à extraire
à partir du référentiel local - ceci est utile lors de la fusion de branches locales
dans la branche actuelle.
Notez également que les options destinées à git-pull lui-même et à git-merge sous-jacent
doit être donné avant les options destinées à git-fetch.
Vous tireriez si vous voulez que les historiques fusionnent, vous récupéreriez si vous «voulez juste le codez» car une personne a tagué des articles ici.
|
Vous pouvez récupérer à partir d'un référentiel distant, voir les différences, puis extraire ou fusionner.
Voici un exemple pour un référentiel distant appelé origine et une branche appelée master suivant l'origine / maître de la branche distante:
git checkout master
git chercher
git diff origin / master
git rebase origin master
|
La réponse courte et simple est que git pull est simplement git fetch suivi de git merge.
Il est très important de noter que git pull fusionnera automatiquement que vous le vouliez ou non. Cela pourrait bien sûr entraîner des conflits de fusion. Disons que votre télécommande est d'origine et que votre branche est maître. Si vous git diff origin / master avant de tirer, vous devriez avoir une idée des conflits de fusion potentiels et pouvez préparer votre branche locale en conséquence.
En plus de tirer et de pousser, certains flux de travail impliquent git rebase, comme celui-ci, que je paraphrase à partir de l'article lié:
git pull origin master
git checkout foo-branch
git rebase master
git push origine foo-branch
Si vous vous trouvez dans une telle situation, vous pourriez être tenté de git pull --rebase. À moins que vous ne sachiez vraiment, vraiment ce que vous faites, je vous le déconseille. Cet avertissement provient de la page de manuel de git-pull, version 2.3.5:
Il s'agit d'un mode de fonctionnement potentiellement dangereux. Il réécrit
l'histoire, ce qui n'est pas de bon augure lorsque vous avez publié cette histoire
déjà. N'utilisez cette option que si vous avez lu git-rebase (1)
soigneusement.
|
OK, voici quelques informations sur git pull et git fetch, afin que vous puissiez comprendre les différences réelles ... en quelques mots simples, fetch obtient les dernières données, mais pas les changements de code et ne va pas gâcher votre code de branche locale actuel , mais tirez pour obtenir les modifications de code et fusionnez-le dans votre branche locale, lisez la suite pour obtenir plus de détails sur chacun:
git chercher
Il téléchargera toutes les références et objets et toutes les nouvelles branches dans votre référentiel local ...
Récupérer des branches et / ou des balises (collectivement, "refs") d'un ou plusieurs
autres référentiels, ainsi que les objets nécessaires pour compléter leur
histoires. Les branches de suivi à distance sont mises à jour (voir la description
ci-dessous pour savoir comment contrôler ce comportement).
Par défaut, toute balise qui pointe vers les historiques en cours de récupération est
également récupéré; l'effet est de récupérer les balises qui pointent vers les branches qui
qui vous intéresse. Ce comportement par défaut peut être modifié en utilisant
les options --tags ou --no-tags ou en configurant
remote..tagOpt. En utilisant une refspec qui récupère les balises explicitement,
vous pouvez récupérer les balises qui ne pointent pas vers les branches qui vous intéressent
dans aussi.
git fetch peut récupérersoit un référentiel ou une URL nommé unique, ou
à partir de plusieurs référentiels à la fois si est donné et qu'il y a un
télécommandes. entrée dans le fichier de configuration. (Voir git-config1).
Lorsqu'aucune télécommande n'est spécifiée, la télécommande d'origine sera par défaut
utilisé, sauf si une branche en amont est configurée pour le courant
branche.
Les noms des références récupérées, ainsi que les noms des objets
ils pointent vers, sont écrits dans .git / FETCH_HEAD. Ces informations peuvent être
utilisé par des scripts ou d'autres commandes git, telles que git-pull.
git pull
Il appliquera les modifications de la branche distante à la branche actuelle en local ...
Incorpore les modifications d'un référentiel distant dans la branche actuelle.
Dans son mode par défaut, git pull est un raccourci pour git fetch suivi de
git merge FETCH_HEAD.
Plus précisément, git pull exécute git fetch avec les paramètres donnés et
appelle git merge pour fusionner les têtes de branche récupérées dans le courant
branche. Avec --rebase, il exécute git rebase au lieu de git merge.
doit être le nom d'un référentiel distant tel qu'il est passé à
git-fetch1. peut nommer une référence distante arbitraire (par exemple,
le nom d'un tag) ou même une collection de refs avec correspondant
les branches de suivi à distance (par exemple, refs / heads /: refs / remotes / origin /),
mais il s'agit généralement du nom d'une branche dans le référentiel distant.
Les valeurs par défaut pour et sont lues à partir de
Configuration "remote" et "merge" pour la branche actuelle telle que définie par
git-branch --track.
Je crée également le visuel ci-dessous pour vous montrer comment git fetch et git pull fonctionnent ensemble ...
|
Cette représentation graphique interactive est très utile pour comprendre git: http://ndpsoftware.com/git-cheatsheet.html
git fetch "télécharge" simplement les modifications de la télécommande vers votre référentiel local. git pull télécharge les modifications et les fusionne dans votre branche actuelle. "Dans son mode par défaut, git pull est un raccourci pour git fetch suivi de git merge FETCH_HEAD."
|
Prime:
En parlant de pull & fetch dans les réponses ci-dessus, je voudrais partager une astuce intéressante,
git pull --rebase
Cette commande ci-dessus est la commande la plus utile de ma vie git qui a sauvé beaucoup de temps.
Avant de pousser vos nouveaux commits sur le serveur, essayez cette commande et elle synchronisera automatiquement les dernières modifications du serveur (avec une extraction + fusion) et placera votre commit en haut de git log. Pas besoin de s'inquiéter de l'extraction / fusion manuelle.
Trouvez des détails sur: http://gitolite.com/git-pull--rebase
|
J'aime avoir une représentation visuelle de la situation pour saisir ces choses. Peut-être que d'autres développeurs aimeraient le voir aussi, alors voici mon ajout. Je ne suis pas tout à fait sûr que tout soit correct, alors veuillez commenter si vous trouvez des erreurs.
SYSTÈME LOCAL
. =================================================== ===
==================. ================= ==================== ==============
REPOSITAIRE A DISTANCE. RÉPERTOIRE À DISTANCE RÉPERTOIRE LOCAL COPIE DE TRAVAIL
(ORIGINE)          . (CACHÉ)
par exemple,      . miroir du
un dépôt github. . repo distant
Peut également être       .
plusieurs repo.
.
.
FETCH * ------------------> *
Votre cache local de la télécommande est mis à jour avec l'origine (ou plusieurs
sources externes, c'est la nature distribuée de git)
.
TIRER   *------------------------------------------------ --------> *
les modifications sont directement fusionnées dans votre copie locale. lorsque des conflits surviennent,
on vous demande des décisions.
.
S'ENGAGER. * <--------------- *
Lorsque vous venez, par exemple, de subversion, vous pourriez penser qu'un commit
mettra à jour l'origine. Dans git, un commit n'est effectué que sur votre dépôt local.
.
PUSH * <--------------------------------------- *
Synchronise vos modifications dans l'origine.
Certains avantages majeurs pour avoir un miroir récupéré de la télécommande sont:
Performance (faites défiler tous les commits et messages sans essayer de les faire passer à travers le réseau)
Commentaires sur l'état de votre dépôt local (par exemple, j'utilise SourceTree d'Atlassian, qui me donnera une ampoule indiquant si je commets en avance ou en retard par rapport à l'origine. Ces informations peuvent être mises à jour avec un GIT FETCH).
|
J'ai également eu du mal avec cela. En fait, je suis arrivé ici avec une recherche Google sur exactement la même question. La lecture de toutes ces réponses a finalement peint une image dans ma tête et j'ai décidé d'essayer de le faire en regardant l'état des 2 référentiels et 1 bac à sable et les actions effectuées au fil du temps tout en regardant leur version. Alors, voici ce que j'ai trouvé. Veuillez me corriger si je me suis trompé quelque part.
Les trois dépôts avec un fetch:
--------------------- ----------------------- ------ -----------------
- Repo à distance - - Repo à distance - - Repo à distance -
- - - est poussé - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------------------------------
- Repo local - - Repo local - - Repo local -
- tirer - - - - chercher -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Bac à sable local - - Bac à sable local - - Bac à sable local -
- Checkout - - nouveau travail effectué - - -
- @ R01 - - @ R01 + - - @ R01 + -
--------------------- ----------------------- ------ -----------------
Les trois repos avec un pull
--------------------- ----------------------- ------ -----------------
- Repo à distance - - Repo à distance - - Repo à distance -
- - - est poussé - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Repo local - - Repo local - - Repo local -
- tirer - - - - tirer -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Bac à sable local - - Bac à sable local - - Bac à sable local -
- Checkout - - nouveau travail effectué - - fusionné avec R02 -
- @ R01 - - @ R01 + - - @ R02 + -
--------------------- ----------------------- ------ -----------------
Cela m'a aidé à comprendre pourquoi une récupération est assez importante.
|
La différence entre GIT Fetch et GIT Pull peut être expliquée avec le scénario suivant:
(En gardant à l'esprit que les images parlent plus fort que les mots!, J'ai fourni une représentation picturale)
Prenons un exemple que vous travaillez sur un projet avec les membres de votre équipe. Il y aura donc une branche principale du projet et tous les contributeurs doivent le fourcher dans leur propre référentiel local puis travailler sur cette branche locale pour modifier / ajouter des modules puis repousser vers la branche principale.
Donc,
L'état initial des deux branches lorsque vous avez forké le projet principal sur votre référentiel local sera comme ceci - (A, B et C sont des modules déjà terminés du projet)
Maintenant, vous avez commencé à travailler sur le nouveau module (supposons D) et lorsque vous avez terminé le module D, vous voulez le pousser vers la branche principale, mais en attendant ce qui se passe, c'est qu'un de vos coéquipiers a développé un nouveau module E, F et modifié C.
Alors maintenant, ce qui s'est passé, c'est que votre référentiel local manque par rapport à la progression originale du projet et que le fait de pousser vos modifications vers la branche principale peut conduire à des conflits et provoquer un dysfonctionnement de votre module D.
Pour éviter de tels problèmes et travailler en parallèle avec l'avancement initial du projet, il existe deux façons:
1. Git Fetch - Cela téléchargera toutes les modifications qui ont été apportées au projet de branche d'origine / principale qui ne sont pas présentes dans votre branche locale. Et attendra que la commande Git Merge applique les modifications qui ont été récupérées dans votre référentiel ou branche.
Alors maintenant, vous pouvez surveiller attentivement les fichiers avant de les fusionner avec votre référentiel. Et vous pouvez également modifier D si nécessaire en raison de Modified C.
2. Git Pull - Cela mettra à jour votre branche locale avec la branche origin / main, c'est-à-dire que ce qu'elle fait est une combinaison de Git Fetch et Git fusionnent les unes après les autres.
Mais cela peut provoquer des conflits, il est donc recommandé d'utiliser Git Pull avec une copie propre.
|
Nous disons simplement:
git pull == git fetch + git merge
Si vous exécutez git pull, vous n'avez pas besoin de fusionner les données en local. Si vous exécutez git fetch, cela signifie que vous devez exécuter git merge pour obtenir le dernier code sur votre machine locale. Sinon, le code de l'ordinateur local ne serait pas modifié sans fusion.
Ainsi, dans Git Gui, lorsque vous récupérez, vous devez fusionner les données. La récupération elle-même n'effectuera pas les modifications de code dans votre local. Vous pouvez vérifier cela lorsque vous mettez à jour le code en récupérant
une fois aller chercher et voir; le code, il ne changera pas. Ensuite, vous fusionnez ... Vous verrez le code modifié.
|
git fetch extrait le code du serveur distant vers vos branches de suivi dans votre référentiel local. Si votre télécommande est nommée origin (par défaut), alors ces branches seront dans origin /, par exemple origin / master, origin / mybranch-123, etc. Ce ne sont pas vos branches actuelles, ce sont des copies locales de ces branches du serveur .
git pull fait une extraction git mais fusionne également le code de la branche de suivi dans votreversion locale de cette branche. Si vous n'êtes pas encore prêt pour ces changements, commencez par git chercher.
|
git fetch récupérera les branches distantes afin que vous puissiez git diff ou git les fusionner avec la branche actuelle. git pull exécutera fetch sur la brach distante suivie par la branche actuelle et fusionnera le résultat. Vous pouvez utiliser git fetch pour voir s'il existe des mises à jour de la branche distante sans avoir besoin de les fusionner avec votre branche locale.
|
Git Fetch
Vous téléchargez les modifications apportées à votre succursale locale depuis l'origine jusqu'à la récupération. Fetch demande au dépôt distant toutes les validations que d'autres ont effectuées mais que vous n'avez pas sur votre dépôt local. Fetch télécharge ces commits et les ajoute au référentiel local.
Git Merge
Vous pouvez appliquer les modifications téléchargées via l'extraction à l'aide de la commande merge. Merge prendra les commits récupérés de fetch et essaiera de les ajouter à votre branche locale. La fusion conservera l'historique de validation de vos modifications locales afin que lorsque vous partagerez votre branche avec push, Git saura comment les autres peuvent fusionner vos modifications.
Git Pull
L'extraction et la fusion s'exécutent assez souvent ensemble pour qu'une commande combinant les deux, pull, soit créée. Pull effectue une extraction puis une fusion pour ajouter les commits téléchargés dans votre branche locale.
|
En termes simples, si vous étiez sur le point de monter dans un avion sans connexion Internet ... avant de partir, vous pouvez simplement faire git fetch origin . Il récupérerait toutes les modifications dans votre ordinateur, mais le garderait séparé de votre espace de développement / de travail local.
Dans l'avion, vous pouvez apporter des modifications à votre espace de travail local, puis le fusionner avec ce que vous avez récupéré et résoudre les conflits de fusion potentiels, le tout sans connexion à Internet. Et à moins que quelqu'un n'ait apporté de nouvelles modifications au référentiel distant, une fois arrivé à destination, vous feriez git push origin  et iriez chercher votre café.
À partir de ce didacticiel Atlassian génial:
La commande git fetch télécharge les commits, les fichiers et les références à partir d'un
référentiel distant dans votre référentiel local.
La récupération est ce que vous faites lorsque vous voulez voir ce que tout le monde a
travaillé sur. Elle est similaire à la mise à jour SVN en ce qu'elle vous permet de voir
comment l'histoire centrale a progressé, mais cela ne vous oblige pas à
fusionne réellement les modifications dans votre référentiel. Git isole
extrait du contenu en tant que contenu local existant, il a absolument
aucun effet sur votre travail de développement local. Le contenu récupéré doit être explicitement extrait à l'aide de la commande git checkout. Cela fait
chercher un moyen sûr de réviser les commits avant de les intégrer à
votre référentiel local.
Lors du téléchargement de contenu à partir d'un référentiel distant, les commandes git pull et git fetch sont disponibles pour accomplir la tâche. Vous pouvez envisager
git récupère la version "sûre" des deux commandes. Il va télécharger
le contenu distant, mais ne pas mettre à jour l'état de fonctionnement de votre référentiel local,
laissant votre travail actuel intact. git pull est le plus agressif
alternative, il téléchargera le contenu distant pour le local actif
branchez et exécutez immédiatement git merge pour créer un commit de fusion
pour le nouveau contenu distant. Si vous avez des modifications en attente en cours
cela provoquera des conflits et lancera la résolution des conflits de fusion
couler.
Avec git pull:
Vous n'obtenez aucun isolement.
Il n'a pas besoin d'être explicitement extrait. Parce qu'il fait implicitement une fusion git.
L'étape de fusion affectera votre développement local et peut provoquer des conflits
Ce n'est fondamentalement PAS sûr. C'est agressif.
Contrairement à git fetch où il n'affecte que votre .git / refs / remotes, git pull affectera à la fois vos .git / refs / remotes et .git / refs / heads /
Hmmm ... donc si je ne mets pas à jour la copie de travail avec git fetch, alors où dois-je apporter des modifications? Où Git récupère-t-il les nouveaux commits?
Excellente question. Cela le place dans un endroit isolé de votre copie de travail. Mais encore une fois où? Découvrons-le.
Dans votre répertoire de projet (c'est-à-dire où vous exécutez vos commandes git), faites:
ls. Cela montrera les fichiers et répertoires. Rien de cool, je sais.
Maintenant, faites ls -a. Cela affichera les fichiers de points, c'est-à-dire les fichiers commençant par. Vous pourrez alors voir un répertoire nommé: .git.
Faites cd .git. Cela changera évidemment votre répertoire.
Maintenant vient la partie amusante; faire ls. Vous verrez une liste de répertoires. Nous recherchons des arbitres. Faites des références cd.
Il est intéressant de voir ce qu'il y a dans tous les répertoires, mais concentrons-nous sur deux d'entre eux. têtes et télécommandes. Utilisez également cd pour vérifier à l'intérieur d'eux.
Toute extraction git que vous effectuez mettra à jour les éléments du répertoire /.git/refs/remotes. Il ne mettra à jour rien dans le répertoire /.git/refs/heads.
Tout git pull effectuera d'abord git fetch, mettra à jour les éléments du répertoire /.git/refs/remotes, puis fusionnera avec votre fichier local, puis changera la tête dans le répertoire /.git/refs/heads.
Une très bonne réponse connexe peut également être trouvée dans Où se place «git fetch»?.
Recherchez également la "notation Slash" dans l'article sur les conventions de dénomination des branches Git. Cela vous aide à mieux comprendre comment Git place les chosesdifférents répertoires.
Pour voir la différence réelle
Faites simplement:
git fetch origin master
git checkout master
Si le maître distant a été mis à jour, vous recevrez un message comme celui-ci:
Votre branche est derrière 'origin / master' par 2 commits, et peut être avancée rapidement.
(utilisez "git pull" pour mettre à jour votre branche locale)
Si vous n'avez pas récupéré et que vous venez de faire git checkout master, votre git local ne saurait pas qu'il y a 2 commits ajoutés. Et cela dirait simplement:
Déjà sur 'master'
Votre succursale est à jour avec «origine / maître».
Mais c'est obsolète et incorrect. C'est parce que git vous donnera des commentaires uniquement basés sur ce qu'il sait. Il est inconscient des nouveaux engagements qu'il n'a pas encore supprimés ...
Existe-t-il un moyen de voir les nouvelles modifications apportées à distance tout en travaillant sur la branche localement?
Certains IDE (par exemple Xcode) sont super intelligents et utilisent le résultat d'une récupération git et peuvent annoter les lignes de code qui ont été modifiées dans la branche distante de votre branche de travail actuelle. Si cette ligne a été modifiée à la fois par des modifications locales et par la branche distante, cette ligne est annotée en rouge. Ce n'est pas un conflit de fusion. C'est un conflit de fusion potentiel. C'est un heads-up que vous pouvez utiliser pour résoudre le futur conflit de fusion avant de faire git pull depuis la branche distante.
Astuce amusante:
Si vous avez récupéré une branche distante, par exemple fait:
fonction git fetch origin / 123
Ensuite, cela irait dans votre répertoire de télécommandes. Il n'est toujours pas disponible dans votre répertoire local. Cependant, cela simplifie votre commande vers cette branche distante par DWIM (faites ce que je veux dire):
fonction de paiement git / 123
vous n'avez plus besoin de faire:
git checkout -b fonction / 123 origine / fonction / 123
Pour en savoir plus, lisez ici
|
La seule différence entre git pull et git fetch est que:
git pull extrait d'une branche distante et la fusionne.
git fetch ne récupère que depuis la branche distante mais il ne fusionne pas
c'est-à-dire git pull = git fetch + git merge ...
|
Git permet d'appliquer des commits chronologiquement plus anciens après des commits plus récents.
Pour cette raison, le transfert de commits entre les référentiels est divisé en deux étapes:
Copie des nouveaux commits de la branche distante vers la copie de cette branche distante dans le référentiel local.
(opération repo à repo) master @ remote >> remote / origin / master @ local
Intégrer de nouveaux commits à la branche locale
(opération à l'intérieur du repo) remote / origin / master @ local >> master @ local
Il y a deux façons de faire l'étape 2. Vous pouvez:
Forkez la branche locale après le dernier ancêtre commun et ajoutez de nouveaux commits parallèles aux commits qui sont uniques au référentiel local, finalisés en fusionnant le commit, fermant le fork.
Insérez de nouveaux commits après le dernier ancêtre commun et réappliquez des commits uniques au référentiel local.
Dans la terminologie git, l'étape 1 est git fetch, l'étape 2 est git merge ou git rebase
git pull est git fetch et git merge
|
Git obtient la branche de la dernière version du distant vers le local à l'aide de deux commandes:
git fetch: Git va obtenir la dernière version de la version distante à la version locale, mais elle ne fusionne pas automatiquement.

git fetch origin master
git log -p maître..origin / maître
git merge origin / master
Les commandes ci-dessus signifient que télécharger la dernière version de la branche principale de l'origine depuis la branche distante vers la branche principale d'origine. Et puis compare la branche principale locale et la branche principale d'origine. Enfin, fusionnez.
git pull: Git va obtenir la dernière version de la télécommande et la fusionner dans le local.

git pull origin master
La commande ci-dessus est l'équivalent de git fetch et git merge. En pratique, git fetch peut-être plus sécurisé car avant la fusion, nous pouvons voir les changements et décider de fusionner.
|
Quelle est la différence entre git pull et git fetch?
Pour comprendre cela, vous devez d'abord comprendre que votre git local gère non seulement votre référentiel local, mais également une copie locale du référentiel distant.
git fetch met à jour votre copie locale du référentiel distant. Par exemple, si votre référentiel distant est GitHub, vous souhaiterez peut-être récupérer toutes les modifications apportées dans le référentiel distant dans votre copie locale de celui-ci, le référentiel distant. Cela vous permettra d'effectuer des opérations telles que comparer ou fusionner.
git pull, d'un autre côté, amènera les changements dans le référentiel distant là où vous conserverez votre propre code. En règle générale, git pull effectuera d'abord une extraction git pour mettre à jour la copie locale du référentiel distant, puis il fusionnera les modifications dans votre propre référentiel de code et éventuellement votre copie de travail.
|
git pull == (git fetch + git merge)
git fetch ne change pas les branches locales.
Si vous avez déjà un référentiel local avec une configuration à distance pour le projet souhaité, vous pouvez récupérer toutes les branches et balises pour la télécommande existante à l'aide de git fetch. ... Fetch n'apporte aucune modification aux branches locales, vous devrez donc fusionner une branche distante avec une branche locale appariée pour incorporer les modifications nouvellement récupérées. depuis github
|
Une représentation graphique simple pour les débutants,
ici,
git pull
va chercher le codeà partir du référentiel et rebase avec votre local ... dans git pull, il est possible que de nouveaux commits soient créés.
mais en ,
git chercher
récupérera le code du référentiel et nous devons le rebaser manuellement en utilisant git rebase
par exemple: je vais aller chercher du maître du serveur et le rebaser dans mon maître local.
1) git pull (le rebase se fera automatiquement):
git pull origin master
ici l'origine est votre repo master distant est votre succursale
2) git fetch (besoin de rebaser manuellement):
git fetch origin master
il récupérera les modifications du serveur depuis l'origine. et il sera dans votre local jusqu'à ce que vous le rebasiez vous-même. nous devons résoudre les conflits manuellement en vérifiant les codes.
git rebase origin / master
cela rebasera le code en local. avant cela, assurez-vous que vous êtes dans la bonne branche.
|
Essayer d'être clair et simple.
La commande git pull est en fait un raccourci pour git fetch suivi de la commande git merge ou de la commande git rebase selon votre configuration. Vous pouvez configurer votre référentiel Git de sorte que git pull soit une extraction suivie d'un rebase.
|
En fait, Git conserve une copie de votre propre code et
le référentiel distant.
La commande git fetch met à jour votre copie locale en récupérant les données du référentiel distant. La raison pour laquelle nous en avons besoin est que quelqu'un d'autre a peut-être apporté des modifications au code et que vous souhaitez vous tenir au courant.
La commande git pull apporte les modifications du référentiel distant là où vous conservez votre propre code. Normalement, git pull le fait en effectuant d'abord un 'git fetch' pour mettre à jour la copie locale du dépôt distant, puis il fusionne les modifications dans votre propre dépôt de code et éventuellement votre copie de travail.
|
1
2
Prochain
Question très active. Gagnez 10 points de réputation pour répondre à cette question. L'exigence de réputation permet de protéger cette question contre les spams et les activités sans réponse.
Ce n'est pas la réponse que vous recherchez? Parcourez les autres questions marquées git version-control git-pull git-fetch ou posez votre propre question.